Systems and methods for a snapshot of data

ABSTRACT

In one embodiment, a user or client device is connected to a distributed file system comprised of one or more physical nodes. The data on each of the physical nodes store metadata about files and directories within the file system. Some of the embodiments permit a user to take a snapshot of data stored on the file system. The snapshot may include a single file, a single directory, a plurality of files within a directory, a plurality of directories, a path on the file system that includes nested files and subdirectories, or more than one path on the file system that each includes nested files and directories. In one embodiment, the metadata comprises mini-snapshots for directories representing a path from the root of the file system to the root of the snapshot. The mini-snapshots serve as stand-ins for portions of the file system which are not included in the snapshot, but which permit access to the snapshot data in an intuitive way.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of and claims benefit of priorityunder 35 U.S.C. §120 to U.S. patent application Ser. No. 11/506,591,filed Aug. 18, 2006, scheduled to issue as U.S. Pat. No. 7,680,842 onMar. 16, 2010, and entitled “Systems and Methods for a Snapshot ofData,” which is hereby incorporated by reference herein in its entirety,and which was filed on the same day as the following applications withthe same title (“Systems and Methods for a Snapshot of Data”), U.S.application Ser. Nos. 11/506,596, 11/506,610, scheduled to issue as U.S.Pat. No. 7,680,836 on Mar. 16, 2010, and 11/507,069, all three of whichare hereby incorporated by reference in their entirety herein.

FIELD OF THE INVENTION

This invention relates generally to a computer system, and morespecifically to taking snapshots of data in a computer system.

BACKGROUND

The amount of data stored on digital computing systems has increaseddramatically in recent years. Accordingly, users have becomeincreasingly reliant on the storage devices of these systems to storethis data. Typically, the data stored on the storage devices undergomodifications. These modifications may arise from user intervention,periodic system updates or alterations, computer initiated processes, orsome other source. Whatever the source of the modifications, it is oftenuseful to preserve and permit access to previous versions of the datasuch as, for example, files and directories. Some instances of whenaccess to previous versions may be useful include, but are not limitedto, inadvertently deleted or overwritten data, providing external accessto older versions of data while newer versions are being updated, anddetermining changes to storage device usage over time.

One response to preserving older versions of files has been to copy theentire contents of the storage device to a backup or second storagedevice. A digital computing system employing this technique will oftenencounter numerous problems. One, copying entire data systems is timeconsuming and delays write requests to data on the storage device.Second, this type of backup is financially expensive because it oftenrequires the purchase of additional storage space. Finally, this optiondoes not permit system flexibility. Backups of portions of the filesystem can reduce the time and expense encountered with traditionalmethods.

Moreover, the aforementioned problems are amplified when modern,large-capacity storage devices and distributed storage systemscomprising numerous large-capacity storage devices are considered.

Because of the foregoing challenges and limitations, there is a need toprovide a more efficient manner in which to provide snapshots of data ina system.

SUMMARY OF THE INVENTION

The embodiments disclosed herein generally relate to a computer system,and more specifically to taking snapshots of data in a computer system.

One embodiment of the present invention includes a method for taking asnapshot of a portion of a file system including files and directories.The method may include accepting at least one path that represents aportion of a file system where the portion is less than the entire filesystem; retrieving at least one data structure that represents thetop-most level of the at least one path; and prior to any modificationsof the portion of the file system represented by the at least one path,indicating in the at least one data structure that the at least one pathis governed by a snapshot.

Another embodiment of the present invention includes a data structurefor tracking modifications in a file system. The data structure mayinclude a first representation of a snapshot that is associated with thedata structure; and a second representation of data structures governedby the snapshot that have been modified.

An additional embodiment of the present invention includes a datastructure associated with files or directories in a file system. Thedata structure may include an identification field comprised of a firstportion and second portion, wherein the first portion is common toversions of the data structure and the second portion is unique to aparticular version of the data structure; a representation of snapshotsthat govern the data structure; and a last access field that indicateswhen the representation was last updated.

A further embodiment of the present invention includes a system foraccessing snapshot data in a file system. The system may include astorage device comprising a file system; and a processor operablycoupled to the storage device configured to accept an access request toa path corresponding to a portion of the file system, determine that theportion of the file system is governed by a snapshot, identify locationsin the storage device that store snapshot data, retrieve the snapshotdata; and generate an indication that the snapshot data is not thecurrent version of the data.

Another embodiment of the present invention includes a data storagesystem with per-file snapshot capability. The data storage system mayinclude directory and file nodes forming a data structure tree; and asoftware snapshot module configured to allow for preservation of data ona per-file basis as of a given point in time.

An additional embodiment of the present invention includes a datastorage system with snapshot capability on a per directory anddownstream files basis. The data storage system may include a directoryand file nodes forming a data structure tree; and a software snapshotmodule configured to preserve data stored in all directories and filesdownstream of the directory which is both closest to the files thatinclude the desired data to be preserved as of a given time and fromwhich directory paths lead down to all said files including the desiredsnapshot data.

A further embodiment of the present invention includes a method ofpreserving data stored in a storage system as of a selected time. Themethod may include identifying the file within the storage system thatincludes the desired data to be preserved as of a selected time; andpreserving all the data within said file as of said selected time.

An additional embodiment of the present invention includes a method ofpreserving data stored in a storage system as of a selected time. Themethod may include identifying the files within the storage system thatinclude the desired data to be preserved as of a selected time;identifying the directory in the directory/file tree closest to all theidentified files and from which paths lead down to the identified files;and preserving the data in all the files downstream of the identifieddirectory including all downstream files, if any, that were notidentified as including data desired to be preserved as of said selectedtime.

Another embodiment of the present invention includes a method ofmodifying data in a file stored in a processor accessible storage systemwhile preserving data stored in the file as of a point in time. Themethod may include locating the desired file within a hierarchicalstorage structure; and checking a node at least one level up thehierarchical storage structure leading to the desired file for anindication that data existing in the file prior to modification shouldbe preserved.

A further embodiment of the present invention includes a processoraccessible data storage system allowing for the preservation of data ina file as of a point in time. The system may include a hierarchicalstructure for storing data including directory nodes and file nodes; andan indication that the data in a file should be preserved as ofspecified point in time stored initially at a node other than the filenode.

An additional embodiment of the present invention includes a method ofaccessing the data stored in a storage system as of a selected point intime. The method may include locating the desired file within an indexstorage structure using a file identifier and a snapshot identifier; andchecking the index storage structure for the desired file to determineif any information stored in the file has been modified since theselected point in time.

A further embodiment of the present invention includes a method oftracking files to be traversed. The method may include storing a set ofdata structures that correspond to a plurality of files that arelogically stored in a tree; tracking a set of snapshots that governsubsets of files in the tree; receiving an identifier for a first fileto be modified; and determining whether the first file is governed byany of the set of snapshots by traversing at least a portion of thetree.

Another embodiment of the present invention may include a system fortracking snapshots of a file system. The system may include a filestructure comprising a plurality of files that are logically stored in atree; for each of the plurality of files, a data structure correspondingto each of the files and directories, the data structure comprising anindication of the snapshot data currentness of the data structure; amodification module configured to receive a request to modify one of theplurality of files; and an update module configured to update at leastone of the data structures to determine whether the at least one datastructure is governed by a snapshot.

A further embodiment of the invention includes a processor accessibledata storage system allowing for the storage of data representing a filesystem with a root-accessible directory-level snapshot structure. Thesystem may include a hierarchical structure for storing data including aroot directory node, directory nodes, and file nodes; and arepresentation of a snapshot of at least one branch of the hierarchicalstructure, at least one branch comprising a top node; a sequence of atleast one mini-snapshot node representing a path from the root directorynode to the top node at the time of the creation of the snapshot, eachmini-snapshot node comprising a reference from the mini-snapshot node toa child mini-snapshot node or the top node.

An additional embodiment of the invention includes a method ofmaintaining path-accessibility for snapshots in subnodes of ahierarchical structure. The method may include receiving an indicationof at least one branch of a hierarchical structure, at least one branchcomprising a top node; and generating a mini-snapshot of an ancestornode of the top node, the mini-snapshot comprising a reference from themini-snapshot node to a child mini-snapshot node or the top node.

Another embodiment of the invention includes a data storage systemcapable of preserving data snapshots of portions of the stored data asof selected points in time. The data structure may include a datastorage tree structure to store current data in directories and files; asnapshot module configured to create snapshots in time of directoriesand files; and snapshot data structures of snapshot versions of a file,wherein the snapshot file version identifies blocks of data modifiedfrom the next more recent version of the file.

A further embodiment of the invention includes a method of preservingsnapshots of data as of selected points in time in a hierarchical datastorage structure including files. The method may include creating afirst snapshot file version of a current file when a snapshot of aportion of data in the data storage structure which includes said fileis taken, wherein said first snapshot file version is separate andindependent of the current file version and references blocks of thenext more recent snapshot version of the file that are the same as thefirst snapshot file version and stores direct references to blocks whichare different from the next more recent snapshot version of the file,wherein the next more recent snapshot version of the file is the currentfile; creating a second snapshot file version of a current file when asnapshot of a portion of data in the data storage structure whichincludes said file is taken, wherein said second snapshot file versionis separate and independent of the current file version and referencesblocks of the next more recent snapshot version of the file that are thesame as the current snapshot file version and stores direct referencesto blocks which are different from the next more recent snapshot versionof the file; and wherein the next more recent snapshot version of thefile for the second snapshot file version is the current file and thenext more recent snapshot version of the file for the first snapshotfile is the second snapshot file version.

An additional embodiment of the invention may include a data storagesystem capable of preserving data snapshots of portions of the storeddata as of selected points in time. The system may include a datastorage tree structure to store current data in directories and files; asnapshot module configured to create snapshots in time of directoriesand files; and snapshot data structures of snapshot versions of adirectory, wherein the snapshot directory version identifies children ofthe directory that are different from the next more recent version ofthe directory.

A further embodiment of the present invention includes a data storagesystem accessible by a processor. The data storage system may include ahierarchical data storage structure with directory nodes and file nodesin a tree structure, at least some of said directory nodes having aplurality of file nodes as children; a snapshot identifier associatedwith a directory to designate a snapshot as of a given time, thesnapshot including the directory and all subdirectories, if any, and allfiles under the directory; and the same snapshot identifier associatedwith each of the subdirectories, if any, and files under the directory.

An additional embodiment of the present invention includes a method oftraversing a portion of data stored hierarchically in a data storagesystem in which the portion of the data represents a snapshot of thedata stored in said system as of a point in time. The method may includeidentifying the desired snapshot point in time and the desired file orfiles within the storage system; and traversing the nodes of the storagesystem that are identified at the nodes as associated with the desiredsnapshot to find the desired file or files.

Another embodiment of the present invention includes a storage systemthat track of a plurality of versions of selected data portions as ofselected points in time. The storage system may include a snapshotmodule configured to track multiple snapshots of the same and/ordifferent portions of the data stored in said storage system atsubstantially the same and/or different points in time; a data structureconfigured to store the current data of the storage system and to storethe snapshot versions of the data generally only to the extent thesnapshot versions of the data differ from the storage system's currentdata; snapshot data structures related to the snapshot versionsconfigured to store information about nodes within the snapshot versionsthat have been modified; and said snapshot module further configured topermit deletion of any one or more of the snapshot versions of the dataafter reviewing the modified nodes indicated in the snapshot datastructures that correspond to the one or more snapshot versions to bedeleted.

A further embodiment of the present invention includes a method forkeeping track of snapshots in a storage system. The method may includecreating a snapshot tracking file when a snapshot is created, whereinthe snapshot identifies certain data stored in the storage system to bepreserved as of a particular point in time; adding a data identifier tothe snapshot tracking file whenever data stored in the storage systemand covered by the snapshot is modified; and using the information inthe snapshot tracking file to recreate the snapshot data when this isdesired.

An additional embodiment of the present invention includes a method ofdeleting a snapshot in a storage system wherein the storage system iscomprised of a hierarchical data structure of directory and file nodeswherein generally only the portions of blocks of data that have beenmodified by the system are stored in the snapshot portion of the storagesystem to permit recreation of the data as of the point in time of thesnapshot, the method of deletion of a snapshot. The method may includevesting all files covered by the snapshot which have been modified sincethe creation of the snapshot; deleting the reference to the snapshot inthe active snapshot list; and deleting blocks of data no longer in use.

For purposes of this summary, certain aspects, advantages, and novelfeatures of the invention are described herein. It is to be understoodthat not necessarily all such advantages may be achieved in accordancewith any particular embodiment of the invention. Thus, for example,those skilled in the art will recognize that the invention may beembodied or carried out in a manner that achieves one advantage or groupof advantages as taught herein without necessarily achieving otheradvantages as may be taught or suggested herein.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A illustrates one embodiment of the connections of physical nodesin one embodiment of a distributed file system.

FIG. 1B illustrates one embodiment of a physical node in a distributedfile system.

FIG. 2A illustrates one embodiment of a file system hierarchy indicatingone embodiment of snapshots taken on the file system hierarchy.

FIGS. 2B (2B-1 and 2B-2) illustrates one embodiment of a file systemhierarchy indicating one embodiment of virtual directories used toaccess snapshot data.

FIG. 3 illustrates one embodiment of elements in an inode datastructure.

FIG. 4A illustrates one embodiment of elements of a snapshot trackingfile immediately after a snapshot has been created.

FIG. 4B illustrates one embodiment of elements of a snapshot trackingfile after modifications have been made to files and/or directoriesgoverned by one embodiment of a snapshot.

FIG. 5 illustrates one embodiment of a LIN table and one embodiment of amini-snapshot.

FIG. 6 illustrates one embodiment of a flowchart of operations forcreating a snapshot.

FIG. 7A illustrates one embodiment of a top-level flowchart ofoperations for modifying a file or a directory.

FIG. 7B illustrates one embodiment of a flowchart of operations forpainting files or directories with governing snapshot data.

FIG. 7C illustrates one embodiment of a flowchart of operations forstoring snapshot data.

FIG. 7D illustrates one embodiment of a flowchart of operations formodifying a file governed by a snapshot.

FIG. 7E illustrates one embodiment of a flowchart of operations formodifying a directory governed by a snapshot.

FIG. 8 illustrates one embodiment of a flowchart of operations fordeleting a snapshot.

FIG. 9 illustrates one embodiment of a flowchart of operations forreading a version of a file.

FIG. 10 illustrates one embodiment of a flowchart of operations forperforming a lookup operation on a version of a directory.

FIG. 11 illustrates one embodiment of a flowchart of operations forperforming a read directory operation on a version of a directory.

FIG. 12A illustrates one embodiment of a logical model file structureimplementation.

FIG. 12B illustrates one embodiment of a physical model file structureimplementation.

FIG. 12C illustrates one embodiment of a hybrid model file structureimplementation.

FIG. 12D illustrates one embodiment of a log-based model file structureimplementation.

FIGS. 13A-D illustrate one embodiment of data structures for oneembodiment of creating snapshots of a file, modifying the file, anddeleting a snapshot of the file.

FIGS. 14A-D illustrate one embodiment of data structures for oneembodiment of creating snapshots of a directory, modifying thedirectory, and deleting a snapshot of the directory.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

Systems, methods, processes, and data structures which represent oneembodiment of an example application of the invention will now bedescribed with reference to the drawings. Variations to the systems,methods, processes, and data structures which represent otherembodiments will also be described.

For purposes of illustration, some embodiments will be described in thecontext of a distributed file system. Embodiments of a distributed filesystem suitable for accommodating embodiments of snapshots disclosedherein are disclosed in U.S. patent application Ser. No. 10/007,003,titled, “SYSTEMS AND METHODS FOR PROVIDING A DISTRIBUTED FILE SYSTEMUTILIZING METADATA TO TRACK INFORMATION ABOUT DATA STORED THROUGHOUT THESYSTEM,” filed Nov. 9, 2001 which claims priority to Application No.60/309,803 filed Aug. 3, 2001, U.S. patent application Ser. No.10/281,467 entitled “SYSTEMS AND METHODS FOR PROVIDING A DISTRIBUTEDFILE SYSTEM INCORPORATING A VIRTUAL HOT SPARE,” filed Oct. 25, 2002, andU.S. patent application Ser. No. 10/714,326 entitled “SYSTEMS ANDMETHODS FOR RESTRIPING FILES IN A DISTRIBUTED FILE SYSTEM,” filed Nov.14, 2003, which claims priority to Application No. 60/426,464, filedNov. 14, 2002, all of which are hereby incorporated by reference hereinin their entirety.

For purposes of illustration, some embodiments will also be describedwith reference to updating data structures in a file system usinginformation stored in related data structures of the file system.Embodiments of a file system capable of updating data structures withinformation stored in related data structures of a file system aredisclosed in U.S. patent application Ser. No. 11/255,337, titled,“SYSTEMS AND METHODS FOR ACCESSING AND UPDATING DISTRIBUTED DATA,” andis hereby incorporated by reference in its entirety.

In one embodiment of a distributed file system, metadata structures,also referred to as inodes, are used to monitor and manipulate the filesand directories within the system. An inode is a data structure thatdescribes a file or directory and may be stored in a variety oflocations including on disk and/or in memory. The inode in-memory mayinclude a copy of the on-disk data plus additional data used by thesystem, including fields associated with the data structure.

As used herein, a file is a collection of data stored in one unit undera filename. A directory, similar to a file, is a collection of datastored in one unit under a directory name. A directory, however, is aspecialized collection of data regarding elements in a file system. Inone embodiment, a file system is organized in a tree-like structure.Directories are organized like the branches of trees. Directories maybegin with a root directory and/or may include other branchingdirectories. Files resemble the leaves or the fruit of the tree. Files,typically, do not include other elements in the file system, such asfiles and directories. In other words, files do not typically branch.Although in the illustrated embodiment an inode represents either a fileor a directory, in other embodiments, an inode may include metadata forother elements in a distributed file system, in other distributedsystems, in other file systems, or other systems.

As used herein, data structures are collections of associated dataelements, such as a group or set of variables or parameters. In oneembodiment a structure may be implemented as a C-language “struct.” Oneskilled in the art will appreciate that many suitable data structuresmay be used.

Some of the figures and descriptions relate to an embodiment of theinvention wherein the environment is that of a distributed file system.The present invention is not limited by the type of environment in whichthe systems, methods, processes and data structures are used. Thesystems, methods, structures, and processes may be used in otherenvironments, such as, for example, other file systems, otherdistributed systems, the Internet, the World Wide Web, a private networkfor a hospital, a broadcast network for a government agency, an internalnetwork of a corporate enterprise, an intranet, a local area network, awide area network, a wired network, a wireless network, and so forth. Itis also recognized that in other embodiments, the systems, methods,structures and processes may be implemented as a single module and/orimplemented in conjunction with a variety of other modules and the like.

I. Overview

In one embodiment, a user or client device is connected to a distributedfile system comprised of one or more physical nodes (for example,storage devices). The data on each of the physical nodes are arrangedaccording to inodes which store metadata about files and directorieswithin the file system. In particular, each inode points to locations ona physical disk that store the data associated with a file or directory.

Some of the embodiments disclosed herein permit a user to take asnapshot of data stored on the file system. The snapshot may include asingle file, a single directory, a plurality of files within adirectory, a plurality of directories, a path on the file system thatincludes nested files and subdirectories, or more than one path on thefile system that each includes nested files and directories.

A path to a file or directory specified to create a snapshot will bereferred to herein as “the root of the snapshot.” For example, thecommand “snap create /ifs/data/dir1” creates a snapshot of directory“dir1” and the files and directories nested within “dir1.” Accordingly,“dir1” is the root of the snapshot. In one embodiment, if the root ofthe snapshot is a file, then the snapshot is of the file only. Thus, thefile is “governed” by the snapshot. If the root of the snapshot is adirectory, then the root of the snapshot and all files and directoriesnested within the root of the snapshot as well as their descendents aregoverned by the snapshot. Accordingly, in some embodiments, more thanone snapshot may govern a particular file or directory.

Additionally, the most current version of data on the file system willbe referred to as the “current version,” “HEAD version,” or “activeversion” whereas, previous versions will be referred to as “snapshotdata,” the “snapshot version,” or “past versions.” In one embodiment, ifthe current version of a file or a directory has been deleted from thesystem, it is possible for a file or directory to have snapshot versionsbut not have a current version.

In one embodiment, when a snapshot is created, it is created in constanttime. That is, no copying of data is required. Instead, a snapshot iscreated by creating a snapshot tracking data structure associated withthe new snapshot, a mini-snapshot(s) if applicable, and an indication inthe governance list field of the metadata structure associated with theroot of the snapshot. A snapshot is said to be created in constant timebecause substantially little time is required to create the snapshot.Accordingly, snapshot creation does not substantially interfere withread requests to files and directories governed by the snapshot. Thisfeature and other features of the embodiments disclosed herein will bedescribed in more detail below.

II. System Architecture

In FIG. 1A, a distributed file system 100 comprises various physicalnodes 101, 102, 103, 104, 105 that communicate over a communicationmedium 106. In one embodiment, the communication medium 106 is the WorldWide Web. In other embodiments, as described above, the distributed filesystem 100 may be comprised of one or more hard-wired connectionsbetween the physical nodes or any combination of communication typesknown to one with ordinary skill in the art.

In the depicted embodiment, the physical nodes are either interfaces101, 102, such as a personal computer, a mainframe terminal or a clientapplication, or data storage systems 103, 104, 105. It will beappreciated by one with ordinary skill in the art that the distributedfile system 100 may comprise one or a plurality of interfaces and one ora plurality of data storage systems. In one embodiment, the interfaces101, 102 may comprise data storage systems such as, for example, datastorage systems 103, 104, and 105.

FIG. 1B illustrates one embodiment of a data storage system 110 of thedistributed file system 100. The data storage system 110 comprisesseveral subcomponents which may include, for example, an Input/OutputInterface 112 that provides for external communication 116, a snapshotmodule 113, a processor 115, and a storage device 114. In oneembodiment, these subcomponents communicate with one another over a bus111. In some embodiments, the data storage systems may include only aportion of the depicted subcomponents or only the storage device 114.

In one embodiment, the snapshot module 113 is capable of executing theprocesses and methods described herein. The word module refers to logicembodied in hardware or firmware, or to a collection of softwareinstructions, possibly having entry and exit points, written in aprogramming language, such as, for example, C or C++. A software modulemay be compiled and linked into an executable program, installed in adynamically linked library, or may be written in an interpretedprogramming language such as, for example, BASIC, Perl, or Python. Itwill be appreciated that software modules may be callable from othermodules or from themselves, and/or may be invoked in response todetected events or interrupts. Software instructions may be embedded infirmware, such as an EPROM. It will be further appreciated that hardwaremodules may be comprised of connected logic units, such as gates andflip-flops, and/or may be comprised of programmable units, such asprogrammable gate arrays or processors. The modules described herein arepreferably implemented as software modules, but may be represented inhardware or firmware. Moreover, although in some embodiments a modulemay be separately compiled, in other embodiments a module may representa subset of instructions of a separately compiled program, and may nothave an interface available to other logical program units.

In one embodiment, the processor 115 receives and processes requests tocreate snapshots, to delete snapshots, to read snapshot data, to modifydata governed by a snapshot, and/or other snapshot related processes. Inother embodiments, the processor 115 executes some or all of theprocesses and/or methods described herein. In yet other embodiments, theprocessor 115 calls the snapshot module to execute snapshot relatedprocesses.

In one embodiment, the storage device 114 stores files and directoriesof the file system and the inode metadata associated with the files anddirectories. Examples of the arrangements of files and directoriesstored on the storage device 114 can be found in FIGS. 2A and 2B. Insome embodiments, the storage device may be a physical disk. In otherembodiments, the storage device may comprise a plurality of physicaldisks in communication with one another and/or the bus. In yet otherembodiments, the storage device may include a magnetic storage medium,an optical disk, a random access memory, a hard drive, and a partitionedportion of a hard drive.

The data storage system 110 may run on a variety of computer systemssuch as, for example, a computer, a server, a smart storage unit, and soforth. In one embodiment, the computer may be a general purpose computerusing one or more microprocessors, such as, for example, an Intel®Pentium® processor, an Intel® Pentium® II processor, an Intel® Pentium®Pro processor, an Intel® Pentium® IV processor, an Intel® Pentium® Dprocessor, an Intel® Core™ processor, an xx86 processor, an 8051processor, a MIPS processor, a Power PC processor, a SPARC processor, anAlpha processor, and so forth. The computer may run a variety ofoperating systems that perform standard operating system functions suchas, for example, opening, reading, writing, and closing a file. It isrecognized that other operating systems may be used, such as, forexample, Microsoft® Windows® 3.X, Microsoft® Windows 98, Microsoft®Windows® 2000, Microsoft® Windows® NT, Microsoft® Windows® CE,Microsoft® Windows® ME, Microsoft® Windows® XP, Palm Pilot OS, Apple®MacOS®, Disk Operating System (DOS), UNIX, IRIX, Solaris, SunOS,FreeBSD, Linux®, or IBM® OS/2® operating systems.

III. User Interface

FIG. 2A illustrates one embodiment of a file system hierarchy indicatingone embodiment of snapshots taken on the file system hierarchy. Asshown, each of the files and directories within the file system 200 isassigned a unique identifier referred to as a Logical Inode Number(“LIN”). The LIN uniquely refers to the on-disk data structures for thefile or directory. For example, the LIN associated with /ifs is 2.Accordingly, this inode will be referred to herein as inode two.

As depicted, the root of the file system 200 is /ifs 201. From here,files and directories branch outward, each with a corresponding inode.In one embodiment, inodes that correspond to directories may have one ormore child inodes and possibly even one or more grandchild,great-grandchild inodes, and/or other descendents. In anotherembodiment, inodes that correspond to files do not have any childinodes. For example, inode four corresponds to the directory /data 203and has child inodes one hundred, five thousand and nine thousand. Thegrandchild inodes of inode four include inodes one hundred one, onehundred two, five thousand one and five thousand two; thegreat-grandchild inodes of inode four include inodes five thousand threeand five thousand four. In other embodiments, inodes corresponding tofiles may have child inodes, grandchild inodes, and so forth.

The dashed lines 221, 222, 223 in FIG. 2A correspond to snapshots of thefile system 200. In one embodiment, each of the snapshots has a snapshotidentifier (“snapshot ID”). In one embodiment, the snapshot ID providesan indication as to the relative time the snapshot was created. Forexample, if the snapshot ID of snapshot A is greater than the snapshotID of snapshot B, it is understood that snapshot A was created aftersnapshot B. In one embodiment, the snapshot ID is assigned to snapshotsbased on a monotonically increasing global snapshot counter (“globalcount”). In other embodiments, the snapshot ID may be randomly assignedor otherwise be unrelated to the relative time the snapshot was created.

In FIG. 2A, snapshot one 221 has snapshot ID 497. The root of snapshotone 221 is data and is represented by the path “/ifs/data/”. Thus,directory data/ 203 is the root of snapshot one 221. Accordingly, data/203 and all of the files and directories 204, 205, 206, 207, 208, 209,210, 211 nested within data/ 203 are governed by snapshot one 221.

Snapshot two 222 has snapshot ID 498. The root of snapshot two 222 isrepresented by the path “/ifs/data/dir1.” Thus, directory dir1/ 205 isthe root of the snapshot two 222. Accordingly, dir1/ 205 and all of thefiles and directories 207, 208 nested within dir1/ 205 are governed bysnapshot two 222. Additionally, because dir1/ 205 is also governed bysnapshot one 221, dir1/ 205 and all of the nested files and directoriesunder dir1/ 205 are governed by both snapshot one 221 and snapshot two222.

Snapshot three 223 has snapshot ID 720. The root of snapshot three 223is represented by the path “/ifs/data/dir2/dir/3/file6”. Thus, file6 212is the root of snapshot three 223. Because no files or directories arenested within file6 212, file6 212 is the only file or directorygoverned by snapshot three 223. However, file6 212 is also governed bysnapshot one 221 because it is a file nested within data/ 203 which isgoverned by snapshot one 221.

FIG. 2B illustrates one embodiment of a file system hierarchy indicatingone embodiment of virtual directories used to access snapshot data. Inthe depicted embodiment, snapshot data can be accessed in two ways, (1)through a top-level .snapshot/ directory 263 or (2) through .snapshot/directories 231, 238, 244, 254 nested within subdirectories of a filesystem hierarchy.

In the depicted embodiment, current versions of the files anddirectories within the file system 200 are represented using rectangles(for example, data/ 203). Virtual directories that provide access tosnapshot data are represented using double rectangles (for example,.snapshot/ 244). Files and directories associated with snapshot one 221are represented using ovals (for example, data/ 265); files anddirectories associated with snapshot two 222 are represented usingtriangles (for example, data/ 283); and files and directories associatedwith snapshot three 223 are represented using trapezoids (for example,data/ 284). In one embodiment, the snapshot versions of files anddirectories on a file system are virtual files and directories.

As shown in FIG. 2B, the top-level .snapshot/ directory 263 is asubdirectory of the root of the file system 201, /ifs. The top-level.snapshot/ directory 263 includes subdirectories for each of the threesnapshots: snap1/ 264 for snapshot one 221, snap2/ 274 for snapshot two222, and snap3/ 278 for snapshot 3 223. Using an operatingsystem-compatible “change directory” command (for example, “cd” forUNIX), a user can access the snapshot data for snapshot one 221 usingthe path /ifs/.snapshot/snap1 264. Once at this path 264, the filesystem will appear as the file system at the time snapshot one 221 wascreated. For example, file6 273 from snapshot one can be accessed usingthe path /ifs/.snapshot/snap1/data/dir2/dir3/file6 273.

The /ifs/.snapshot/snap2/ subdirectory 274 is similar in many respectsto the snap1/ subdirectory 264. The file system appears as it did at thetime of snapshot two 222 was created. However, because snapshot two 222governs only dir1/ 205 and the files 207, 208 nested within it, theparent directory to dir1/ 275 data/283, includes enough information toaccess the snapshot version of dir1/ 275. As used herein, ancestordirectories that are not governed by a snapshot but include childrenfiles or directories to navigate to snapshot data are referred to as“mini-snapshots.” For example, though the current version of data/ 203has as its children file1 204, dir2/ 206, and dir1/ 205, themini-snapshot of data/ 283 for snapshot two 222 has its only child dir1/275.

Mini-snapshots serve as stand-ins for the portions of the directory treebetween the file system root 201 and the root of a snapshot.Consequently, snapshot data can be accessed in an intuitive way withoutbeing computationally expensive.

For example, the .snapshot/snap3/ directory 278 utilizes threemini-snapshot directories, data/ 284, dir2/ 279, and dir3/ 280 toprovide access to the snapshot version of file6 281 governed by snapshotthree 223. Accordingly, each of the mini-snapshot directories, do notstore information unrelated to accessing file6 281; data/ 284 does notstore information related to fuel or dir1/; dir2/ 279 does not storeinformation related to file4; and dir3/ 280 does not store informationrelated to file5.

The embodiment depicted in FIG. 2B also shows how snapshot data can beaccessed via .snapshot/ subdirectories nested within the file systemhierarchy 230. Each directory that includes (or, in some instances,formerly included) data with a snapshot version also has a .snapshotsubdirectory. These .snapshot/ subdirectories 231, 238, 244, 254 aresimilar to the .snapshot/ subdirectory 263 of /ifs 201 in that theypreserve the intuitive feel of the file system 200 when accessingsnapshot versions. Accordingly, the .snapshot/ subdirectories 231, 238,244, 254 also utilize mini-snapshots.

One example of a nested .snapshot/ subdirectory can be found withindata/ 203. The .snapshot/ subdirectory 244 includes threesubdirectories: snap1/ 282, snap2/ 286, and snap3/ 290. Because data/203 is the root of snapshot one 221, the subdirectories and fileslocated within snap1/ 282 appear as the subdirectories and files ofdata/ 203 at the time that snapshot one 221 was created.

Similarly, dir2/ 206 includes a .snapshot/ subdirectory 254 thatincludes snapshot data related to snapshot one 221, snap1/ 255, andsnapshot three 223, snap3/ 260. The data within snap1/ 255 can beaccessed as if /ifs/data/dir2/ 206 was accessed at the time thatsnapshot one 221 was taken. However, the data within snap3/ 260 islimited to only file6 262 because snapshot three 223 only governs file6262. Accordingly, dir2/ 291 and dir3/ 261 are mini-snapshots thatprovide access to file6 262.

The .snapshot/ subdirectory 238 found within dir3/ 210 also includesdata associated with snapshot one 221 and snapshot three 240.Subdirectory snap1/ 239 includes the snapshot versions of file5 241 andfile6 242. In contrast, subdirectory snap3/ 240 only includes thesnapshot version of file6 243 because file6 212 is the root of snapshotthree 223.

Subdirectory dir1/ 205 also includes a .snapshot/ subdirectory 231.Nested within .snapshot/ 231 are subdirectories snap1/ 232 and snap2/235. Each of snap1/ 232 and snap2/ 235 include versions of file2 233,236 and file 3 234, 237 that correspond to the versions of file2 207 andfile3 208 at the times that snapshot one 221 and snapshot two 222 werecreated.

In one embodiment, the .snapshot/ subdirectories 231, 238, 254, 244, 263are virtual directories that are not explicitly represented on disk.Information necessary to create the snapshot data found in each virtualdirectory can be found by consulting the inode of the “parent” of thevirtual directory and the snapshot tracking data structures associatedwith each snapshot version of the files and/or directories nested withinthe parent. The virtual directory can be created by (a) determiningwhich snapshots govern each of the files and directories, and (b)accessing the data associated with each version. In some embodiments, topreserve the intuitive feel of the file system, the subdirectories tothe .snapshot/ directories that specify the snapshot version (forexample, snap1/ 264, snap2/ 274, and snap3/ 278) are also virtualdirectories. In other embodiments, the .snapshot/ directories and/ortheir subdirectory(s) are non-virtual directories that are explicitlyrepresented on disk.

IV. Data Structures

a. Metadata

FIG. 3 illustrates one embodiment of some of the data elements of aninode data structure in a file system. As used herein, the data elementsassociated with a particular inode data structure are referred to as themetadata for the inode. In one embodiment, each element is a field thatstores information about the inode, and the metadata is a collection ofthe information stored in the fields. As used herein, the metadataassociated with a file or directory will be referred to as an inode.

In the depicted embodiment, the fields in the inode metadata structure300 include, but are not limited to, the mode field 301, the LIN field302, the last snapshot identifier field (“last snapshot ID”) 303, andthe governance list field 304. In other embodiments, the metadatastructure 300 may include fewer or more fields, such as a reverse lookuphint field, a name field, and/or a field indicating the amount of datareferenced by the inode. In addition, the metadata structure may bestored using a different type of data structure.

The mode field 301, indicates, for example, whether the inodecorresponds to a file or a directory.

As stated previously, the LIN 302 is a unique identifier in the filesystem for the inode.

The governance list field 304 includes all of the snapshot IDs thatgovern the particular inode. In other words, if the inode corresponds toa version(s) of a file or directory, the snapshot ID associated with theversion(s) appears in the governance list of the inode. For example,when a snapshot of a file or a directory is created, but before anymodifications to the file or directory have been made, the governancelist of the current version will include the snapshot ID of the newlycreated snapshot. However, when that file or directory is modified, theinode associated with the snapshot version will have the snapshot ID inthe governance list and the current version will store an empty set inits governance list. Accordingly, a current version of a file withoutany snapshot versions will also store an empty set in its governancelist. The governance list may be implemented using a variety of datastructures known to one with ordinary skill in the art such as a linkedlist or an array.

The last snapshot ID field 303 includes information about thecorresponding file or directory that was modified. After modification,the version of the modified file or directory is updated or “painted”with the global count (that is, the snapshot ID at the time themodification is made). In one embodiment, updating the inode with theglobal count serves to indicate the last time the governance list of theinode was modified.

In one embodiment, the metadata is implemented using an array. Inanother embodiment, the metadata is implemented using a linked list. Aperson with ordinary skill in the art will recognize that the metadatacan be implemented using a variety of data structures.

b. Snapshot Tracking File

In one embodiment, a snapshot tracking data structure (or, “snapshottracking file”) is created each time a snapshot is created. Accordingly,a snapshot tracking file is associated with each snapshot. The snapshottracking file provides information regarding each file or directorygoverned by a snapshot that was modified or deleted after the snapshotwas taken.

In one embodiment, the snapshot tracking file can be used to determinewhich files and directories of a particular version are examined whendeleting a snapshot. In another embodiment, the snapshot tracking filecan be used to track information about a particular snapshot. Thisinformation may include, but is not limited to, disk usage.

FIG. 4A illustrates one embodiment of elements of a snapshot trackingfile 310 immediately after a snapshot has been created. The snapshottracking file 310 can include several fields such as, for example, asnapshot tracking file LIN field (not shown), a snapshot ID field 311,and LIN fields(s) 312, 313, 314, 315, 316, 317. In other embodiments,the snapshot tracking file 310 may include fewer or more fields thanthose depicted in FIG. 4A.

In one embodiment, the snapshot tracking file LIN field is a uniqueidentifier associated with the snapshot tracking file 310, and issimilar in purpose to the LIN associated with a file or a directory.

In one embodiment, the snapshot ID field 311 is the genesis snapshot IDof the snapshot that the snapshot tracking file 310 corresponds to. Inone embodiment, the genesis snapshot ID is equal to the global count atthe moment the corresponding snapshot was created. In anotherembodiment, the snapshot ID field 311 is equal to the time or arepresentation of the time that the snapshot was created. In yet anotherembodiment, the snapshot ID field 311 is some other identifier thatindicates a correspondence with a related snapshot.

In one embodiment, the LIN field(s) 312, 313, 314, 315, 316, 317 storesthe LINs associated with files or directories that have been modified ordeleted from the file system after the corresponding snapshot wascreated. In another embodiment, the LIN field(s) stores the LINs offiles or directories that have been read after the snapshot was created.In yet another embodiment, the LIN field(s) stores the LINs of files anddirectories accessed before a subsequent snapshot is created. While FIG.4A illustrates a set of six LIN fields, it is recognized that a widenumber of LIN fields may be included and/or a variable number of LINfields may be used, depending on the number of modified LINs.

FIG. 4B illustrates one embodiment of elements of a snapshot trackingdata structure 310 after modifications have been made to files and/ordirectories encompassed by one embodiment of a snapshot. As explainedbelow, with reference to FIGS. 13A-D, the LINs of files and directoriesmodified after snapshot one 221 was taken are added to the snapshottracking file associated with snapshot ID 497. For example, file4 209with LIN 5001, file5 211 with LIN 5003, and file6 212 with LIN 5004 wereeither modified or deleted after snapshot one 211 was taken.

In one embodiment, the snapshot tracking file 310 is a fixed-lengtharray that stores empty sets for LIN fields 312, 313, 314, 315, 316, 317that have not yet been populated. In other embodiments, the snapshottracking file 310 is a linked list that adds entries each time a file ordirectory is modified or deleted. A person with ordinary skill in theart will recognize that a snapshot tracking file can be implementedusing a variety of suitable data structures.

c. LIN Table

FIG. 5 illustrates one embodiment of a LIN table 430 and one embodimentof a mini-snapshot 440. In one embodiment, the LIN table stores theLIN/snapshot ID pairs of all of the files and directories in the system.Accordingly, each LIN/snapshot ID pair references the correspondinginode version of a file or directory using, for example, a pointer.

In one embodiment, the LIN table 430 comprises a plurality of rows 431,432, 433. Each row stores data for a particular version of a file or adirectory. Each row 431, 432, 433 is comprised of several fields 467,468, 469, 470 which may include, but are not limited to, a LIN field467, a snapshot ID field 468, a mini-snapshot flag 469, and a reference(or, pointer) field 470. In another embodiment, the LIN field 467 andthe snapshot ID field 468 comprise a single field. For example, theLIN/snapshot ID pair may be represented using a sixteen byte binaryvalue, with the LIN occupying the most significant bits of the sixteenbyte value and the snapshot ID occupying the least significant bits. Inanother embodiment, the LIN table 430 may include fewer or more fields,such as, for example, the mode, the governance list, the creation date,and so forth.

The LIN field 467 includes the LIN of the inode version that aparticular row 431, 432, 433 in the LIN table 430 references.

The snapshot ID field 468 includes the genesis snapshot ID of the inodeversion that a particular row 431, 432, 433 in the LIN table 430references.

In one embodiment, the mini-snapshot flag field 469 indicates whether adirectory is a mini-snapshot rather than a version of a directory in thefile system. In some embodiments, a mini-snapshot is indicated when theflag is set. In other embodiments, a mini-snapshot is indicated when theflag has been cleared.

In one embodiment, the reference field 470 includes a pointer to theinode that corresponds to a LIN/snapshot ID pair represented in the LINtable. For example, row 431 includes the LIN/snapshot ID pair (4, 701)which points to inode 450. Accordingly, inode four hundred fiftyincludes in its metadata the same LIN 452. Also, inode four hundredfifty includes a governance list 453 that provides a representation ofthe snapshots that govern this version of inode four hundred fifty. Inone embodiment, the governance list 453 does not store the same value(s)as the genesis snapshot ID 468 stored in the LIN table 430.

In some embodiments, the LIN table 430 references inodes 440, 450, 460that further reference metatrees 443, 454, 467. Metatrees are datastructures specific to a version of a file or directory. In oneembodiment, metatrees 443, 454, 467 associated with a directory inodestore references to the children of the inode. For example, the metatree467 for inode four stores references to children with LIN one hundred464, LIN five thousand 465, and LIN nine thousand 466. Thus, the currentversion of inode four has three children. Metatree 443 has only oneentry because it is a mini-snapshot for a file or directory nestedwithin inode one hundred. Therefore, though the current version 460 anda previous version 450 indicate that inode four has three children, theinode 440 associated with the mini-snapshot only references the child443 necessary to access data governed by snapshot 736.

Row 432 in the LIN table 430 has the mini-flag set in the mini-snapshotflag field 469. In the depicted embodiment, when the flag is set, therow in the LIN table 430 references a mini-snapshot. Accordingly, row432 references inode 440 which is a mini-snapshot associated withsnapshot ID 736. In one embodiment, the metadata for an inode associatedwith a mini-snapshot does not include a governance list. In thisembodiment, a governance list is not needed because no data stored inthe data blocks of the inode can be altered because subsequent“versions” of mini-snapshots cannot exist. That is, mini-snapshots areonly used to facilitate downward navigation to snapshot data.

Row 433 in the LIN table 430 references inode 460. In one embodiment,the snapshot ID associated with row 433 is “MAX_INT.” MAX_INT representsa binary value wherein all of the bits are set (for example, all bitsare set to “1”). In one embodiment, the value MAX_INT is used torepresent the current version of a file or directory. For example,whenever the user wishes to modify a file or directory with snapshot IDMAX_INT, the user knows that the current version of the file is beingmodified. In another embodiment, the current version can be assigned asnapshot ID wherein all bits are cleared (for example, all bits are setto “0”). In a further embodiment, the current version can be assigned asnapshot ID with an empty set or some other representation thatidentifies the current version.

In one embodiment, each row 431, 432, 433 is implemented using a fixedlength array. In another embodiment, each row 431, 432, 433 isimplemented using a linked list. In yet another embodiment, the rows areassociated with one another using an array or a linked list. A personwith ordinary skill in the art will recognize that the LIN table can beimplemented using a variety of different data structures.

V. Snapshot Creation

FIG. 6 illustrates one embodiment of a flowchart of operations 400 forcreating a snapshot. In the depicted embodiment, the process 400executes when a snapshot is created. The process 400 begins 401 bygetting the path of the root of the snapshot to be created 402. In oneembodiment, the root of the snapshot is the top-most level in the filesystem hierarchy governed by the snapshot. Accordingly, the snapshotgoverns the root of the snapshot and the descendents of the root of thesnapshot. In one embodiment, the root of the snapshot is either a fileor directory. In other embodiments, the root of the snapshot is only afile or only a directory.

Next, a snapshot tracking file 310 is created 403 with fields including,for example, the snapshot ID field 311 and the LIN field(s) 312, 313,314, 315, 316, 317 empty. Then, the global count is accessed and addedto the snapshot ID field 311 of the snapshot tracking file 310.

After the snapshot tracking file has been created 403 and the globalcount added 404, decision block 405 determines whether the root of thesnapshot is also the root of the file system. If it is the root of thefile system, the operations in blocks 406, 407, and 408 can be skipped.However, if it is not the root of the file system, a for loop for allancestors of the root of the snapshot to the root of the file system 406is initiated.

For all of these ancestors, a mini-snapshot is created 407. In oneembodiment, creating a mini-snapshot includes two steps. First, an inodeis created. The inode comprises at least a mode field and a LIN field.In one embodiment, the mode field indicates that the inode is associatedwith a directory because, in the exemplary embodiment, files cannot havechildren. In other embodiments, where either files or directories mayhave children, the mode field indicates either a file or a directory.The LIN field indicates the LIN of the corresponding ancestor of theroot of the snapshot. Second, a reference is created that points to achild of the ancestor in the path to the root of the snapshot. In someembodiments, a mini-snapshot is a virtual data structure that is createdwhen a snapshot version with mini-snapshots is accessed.

In one embodiment, after the mini-snapshots for all ancestors up until,but not including, the root have been created 407, the for loop ends408. In another embodiment, the for loop ends 408 when mini-snapshotshave been created 407 for all ancestors including the root directory.After the for loop ends 408, the genesis snapshot ID is added to thegovernance list of the inode associated with the current version of theroot of the snapshot 409.

In another embodiment, multiple paths to multiple roots of a snapshotare accepted. It is recognized that a person with ordinary skill in theart would be capable of modifying process 400 to accommodate a snapshotthat has multiple roots.

While FIG. 6 illustrates one embodiment of a create snapshot operation,it is recognized that other embodiments may be used. For example, theinputs and outputs may be passed as values, references, and/or stores inan accessible memory location.

VI. Copy on Write

FIG. 7A illustrates one embodiment of a top-level flowchart ofoperations 600 for modifying a file or a directory. Because theoperations needed for modifying a file or a directory, in someinstances, involve copying data only in response to a write request,some of the operations discussed herein will be referred to as a “copyon write” (“COW”). Moreover, in the depicted embodiment, the top-levelflowchart of operations calls various processes 602, 604, 605, 607 inorder to complete the operation. In other embodiments, some or all ofthese processes may comprise a single process. In yet other embodiments,process 600 may be embodied as a single process.

The process 600 of modifying a file or directory begins 601 by executingthe painting operation 602 depicted in FIG. 7B. After the paintingprocess 602 terminates 636, decision block 603 determines whether thefile or directory that will be modified is governed by a snapshot. Thepainting process 602, in part, can determine whether the file ordirectory is governed by a snapshot. If the file or directory isgoverned by a snapshot, then the create snapshot version of file ordirectory process 604 is executed. However, if the file or directory isnot governed by a snapshot, the create version of file or directoryprocess 604 is skipped.

Next, decision block 606 determines whether a file or a directory isbeing modified. If a file is being modified, the file COW process 605 isexecuted. However, if a directory is being modified, the directory COWprocess 607 is executed. Then, after either the file COW process 605 orthe directory COW process 607 finishes executing, the operation ends608.

While FIG. 7A illustrates one embodiment of a create snapshot operation,it is recognized that other embodiments may be used. For example, theinputs and outputs may be passed as values, references, and/or stores inan accessible memory location.

a. Painting

FIG. 7B illustrates one embodiment of a flowchart of operations 602 forpainting files or directories with governing snapshot data. In oneembodiment, painting is used because the governance list of a file ordirectory is not updated each time a snapshot that governs the file ordirectory is created. For example, if in FIG. 2A, when snapshot one 221was created, only the governance list of data/ 203 is “painted” with thesnapshot ID of snapshot one 221 because it is the root of the snapshot.Faster snapshot creation is facilitated by only painting the root of thesnapshot. However, before modifying a file or directory within data/203, the process traverses up the tree to data/ 203 to discover whetherthe file or directory is governed by snapshot one 221. In otherembodiments, files and directories governed by a snapshot are paintedwhen the snapshot is created. In these embodiments, painting a file ordirectory before modifying with a list of governing snapshots isunnecessary.

In one embodiment, the painting process 602 begins 620 at decision block621 by asking whether the last snapshot ID stored in the file ordirectory to be modified (or “target file/dir”), is less than the globalcount. As discussed previously, the global count can be used to indicatethe relative time when a snapshot was created or when the governancelist of a particular inode was updated. Thus, in the depictedembodiment, the global count is a value that is greater than or equal toany snapshot ID stored in the system. If the last snapshot ID is notless than the global count, then we know that the snapshot ID is equalto the global count and the governance list of the inode is, therefore,up to date. Then, the process ends 636.

However, if the last snapshot ID is less than the global count 621, twovariables are initialized 622: EXAMINED MINIMUM=last snapshot ID+1; andEXAMINED DIRECTORY=parent inode of the target file/dir. Next, a whileloop initiates 623 and executes the operations nested within it whileEXAMINED MINIMUM is less than or equal to the global snapshot count.Therefore, even if the snapshot ID was one less than the global count,the operations in the while loop will execute at least once becauseEXAMINED MINIMUM must be greater than the global snapshot count toterminate the while loop 623.

Next, a for loop 624 considers each inode version of the EXAMINEDDIRECTORY. Within for loop 624, is nested for loop 625 which considerssnapshot ID in the governance list of the considered inode version.

Thus, for each snapshot ID of a particular inode version, decision block626 asks whether the snapshot ID is greater than or equal to EXAMINEDMINIMUM. If it is not, the next snapshot ID is considered 628. In otherwords, if the snapshot ID is not greater than or equal to EXAMINEDMINIMUM, the governance list of the target file/dir was updated afterthe particular snapshot was taken. Thus, the snapshot ID is ignoredbecause it would already be included in the governance list of thetarget file/dir.

However, if the snapshot ID is greater than or equal to EXAMINED MINIMUM626, the snapshot ID is added to the governance list of the targetfile/dir 627. In other words, the snapshot associated with theparticular snapshot ID is more recent than the last time the targetfile/dir was painted 626. Thus, the governance list of the targetfile/dir is updated 627.

Next, after each snapshot ID in a particular version has beenconsidered, the for loop ends 628 and the next version of EXAMINEDDIRECTORY, as dictated by for loop 624, is considered. Then, after allof the snapshot IDs of all of the inode versions of EXAMINED DIRECTORYhave been considered, for loop 624 ends 629.

Decision block 630 then determines whether EXAMINED DIRECTORY is theroot of the file system. If it is the root of the file system, the whileloop 623 breaks 631. After breaking 631, the last snapshot ID field ofthe target file/dir is updated with the global snapshot count 635 toindicate when it was last painted. Then, the painting process 602 ends.

However, if EXAMINED DIRECTORY is not the root of the file system 630,EXAMINED MINIMUM is assigned a value equal to the greater of EXAMINEDMINIMUM and last snapshot ID of EXAMINED DIRECTORY+1 632. In otherwords, block 632 determines whether the EXAMINED DIRECTORY or the childof the EXAMINED DIRECTORY (which was previously considered by for loops624 and 624) was last painted. Then, if EXAMINED DIRECTORY is not out ofdate, as determined by the global snapshot count and the conditionpresented in the while loop 623, EXAMINED DIRECTORY is updated to be theparent of the previous EXAMINED DIRECTORY (given these conditions, atrivial operation) 633, and the while loop 623 ends 634 because EXAMINEDMINIMUM is equal to the global count. Then, the last snapshot ID fieldof the target file/dir is updated with the global count to indicate whenit was last painted 635, and the process ends 636.

Alternatively, if EXAMINED MINIMUM is still less than or equal theglobal snapshot count, the operation of reassigning EXAMINED DIRECTORYto the parent of the previous EXAMINED DIRECTORY 634 is meaningfulbecause the snapshot IDs of all inode versions of the new EXAMINEDDIRECTORY are considered in order to update the governance list of thetarget file/dir 627. The while loop persists until one of two conditionsoccur: the EXAMINED DIRECTORY is the root of the file system 631 or theEXAMINED DIRECTORY is one that is not out of date 634. When either ofthese conditions occur, as explained above, the last snapshot ID of thetarget/file directory is updated 635 and the process ends 636.

While FIG. 7B illustrates one embodiment of a painting operation, it isrecognized that other embodiments may be used. For example, the processmay also paint ancestors of the target file/dir or may use other loopinginstructions. Alternatively, the inputs and outputs may be passed asvalues, references, and/or stores in an accessible memory location.

b. Creating A Snapshot Version

FIG. 7C illustrates one embodiment of a flowchart of operations 604 forcreating a snapshot version. In one embodiment, process 604 creates aninode associated with the snapshot version of a file or directory. Thus,by copying the inode of the target file/dir, creates metadata associatedwith a snapshot version of the file.

In one embodiment, the creating a snapshot version process 604 begins610 by adding the LIN of the target file/dir to the snapshot trackingfile associated with the governing snapshot 611. As stated previously, alist of all modified files or directories governed by a snapshot can beused when deleting the snapshot or performing other functions. Next, theinode of the target file/dir is copied 612. The copy is then added tothe LIN table 612. The LIN table stores the LIN of the target file/dirand the highest snapshot ID in the governance list of the file to bemodified. Then, the create snapshot version process 604 ends.

While FIG. 7C illustrates one embodiment of a creating a snapshotversion operation, it is recognized that other embodiments may be used.For example, the inputs and outputs may be passed as values, references,and/or stores in an accessible memory location.

c. File: Copy on Write

FIG. 7D illustrates one embodiment of a flowchart of operations 605 forCOWing data associated with a modified file. The file COW process 605copies data from the version of the target file to a previous version ofthe file before permitting modification of the current version. Thus,the snapshot version preserves the previous version of the file. In thedepicted embodiment, the process 605 performs a COW based on unitsconsisting of data blocks. Only the data blocks of the file are writtenback to the snapshot version. The data blocks can vary in size and canbe, for example, 1 bit, 8 bytes, 1 megabyte, 100 megabytes, or 1gigabyte. In other embodiments, the entire file is copied to a snapshotversion before the current version is modified.

In the depicted embodiment, the process 604 begins 640 in decision block641 which determines whether there is a previous version of the targetfile. If there is not a previous version of the target file, the versionof the target file can be modified 646 without performing a COW. A COWis unnecessary when a version of the target file does not have aprevious version because that version does not need to be preserved.After the version of the target file has been modified 646, the processends 647.

However, if there is a previous version of the target file, decisionblock 642 asks whether there is a ditto record or indicator for theblock address location(s) (“BADDR”) to be modified in the previousversion. As used herein, BADDRs are used to refer to the physicaladdress of a data block on disk. In the illustrated embodiments, filesare comprised of inodes which store the metadata. The inode references aplurality of BADDR locations stored in a metatree. The BADDR locationscan either point to a data block located on a physical disk or referencethe next version of the target file (referred to herein as a “dittorecord”). If a BADDR location is accessed and it includes an address,then it will use the address to locate data on the physical disk.However, if the BADDR location includes a ditto record, the process willlook to that BADDR location in the metatree of the next most recentversion. If a ditto record is located in that BADDR location, theprocess will look to the BADDR location in the metatree of the sameBADDR location in the metatree of the next most recent version. Thisprocess continues until a BADDR location is reached that includes anaddress. Then, the data is retrieved from the physical disk or thecache.

In one embodiment the metatree is comprised of an array. In otherembodiments, the metatree is comprised of a linked list. In yet otherembodiments, the metatree is comprised of a hybrid of a linked list anda plurality of arrays. A person with ordinary skill in the art willrecognize that other data structures are considered suitable for storinginformation related to file data.

In decision block 642, if a ditto record is not found at a BADDRlocation(s), an address has been found. Thus, the data has already beenCOWed to the BADDR location(s). In other words, the corresponding BADDRlocation(s) has been modified at least once the snapshot was created.Therefore, the BADDR location(s) can be modified in the current version646 directly and the process ends 647.

However, if a ditto record exists at the BADDR location(s), the dittorecord is removed 644. Then, data from the BADDR location(s) of thetarget file is copied to the BADDR location(s) of the previous version645. Next, the BADDR location(s) of the target file are modified 646 andthe process ends 647.

While FIG. 7D illustrates one embodiment of a file COW operation 605, itis recognized that other embodiments may be used. For example, theinputs and outputs may be passed as values, references, and/or stores inan accessible memory location. Additionally, other embodiments mayrepresent and store data common to more than one version using differentdata structures such as, for example, using a physical model, a hybridmodel or a log-based model.

d. Directory: Copy on Write

FIG. 7E illustrates one embodiment of a flowchart of operations 607 forCOWing data associated with a modified directory. The directory COWprocess 607 copies references to old versions of files and directoriesbefore permitting modification. In the depicted embodiment, an inodeassociated with a directory references a metatree that storesinformation about the child inodes located within the directory. In someembodiments, information about child inodes includes, but is not limitedto, the name associated with the child inode, the LIN of the childinode, and the genesis snapshot ID associated with a particular versionof the child inode. In other embodiments, less or more information maybe stored in the metatree such as, for example, the size of the file ordirectory associated with the child inode.

In the depicted embodiment, process 607 begins 650 in decision block 651by determining whether the entry is being added to a target directory orwhether an entry within the target directory is being modified orremoved. In one embodiment, if an entry is being added to the currentversion, it is unnecessary to COW the new entry because previousversions of the target directory do not include the new entry.Consequently, the entry can be added to the metatree associated with thetarget directory 652. Then, the genesis snapshot ID of the entry in themetatree of the target directory is set to the global snapshot count 657and the process ends 658.

If, however, an entry in the target directory is being modified orremoved, decision block 654 asks whether the genesis snapshot ID of theentry is more recent than the most recent snapshot ID in the governancelist of the target directory. If the snapshot ID of the entry is morerecent than the most recent governing snapshot, the entry is notgoverned by a snapshot. Therefore, the entry can be removed or modified655 without COWing the entry to a previous version of the targetdirectory.

However, if the snapshot ID of the entry is not as recent as the latestgoverning snapshot, the entry is copied to the next-most previousversion of the target directory 655 before the target directory can beremoved or modified 656. In some embodiments, the entry is copied to thesame location in the metatree of the previous version.

After the target directory has been modified, the genesis snapshot ID ofthe entry is set to the global count 657, and the process ends 658.

While FIG. 7E illustrates one embodiment of a directory COW operation607, it is recognized that other embodiments may be used. For example,an entry may be added, removed or modified in any version of thedirectory. Additionally, the inputs and outputs may be passed as values,references, and/or stores in an accessible memory location.

VII. Snapshot Deletion

FIG. 8 illustrates one embodiment of a flowchart of operations 480 fordeleting a snapshot. Snapshot deletion is a useful tool for freeingphysical disk resources. For example, suppose a portion of a file systemis used to develop an upcoming software release. Also suppose thatsnapshots are taken of that portion on a daily basis in order topreserve changes to files during the development process. When thesoftware is released, there may no longer be a need to access previousversions of the software. Therefore, a system administrator can utilizethe delete snapshot operation of FIG. 7 in order to free disk spaceoccupied by previous versions. In one embodiment, snapshots older than aspecified time may be deleted. In another embodiment, snapshots thatfall between a specified time range may be deleted. In the depictedembodiment, a single snapshot is deleted.

The delete snapshot process 480 begins 481 by accepting a deletesnapshot request 482 from a user, client application, application, orother source. Next, a for loop 483 considers all files and/ordirectories in the snapshot tracking file. As previously discussed, inone embodiment, the snapshot tracking file comprises a list of all filesand directories that were modified or deleted after the snapshot wascreated.

For each considered file, decision block 484 asks whether a previoussnapshot governs the snapshot to be deleted. If there is not a previousgoverning snapshot, the snapshot version of the considered file ordirectory can be deleted 491. In one embodiment, the version of the fileor directory is deleted without any copy operations because previousversions do not store data referenced by future versions.

Next, the inode associated with the snapshot of the considered file ordirectory is deleted 492. Then the LIN/snapshot ID pair for theconsidered version of the file or directory is deleted from the LINtable 493. Then, for loop 483 considers the next file or directory inthe snapshot tracking file.

However, in decision block 484, if there is a previous snapshot,decision block 485 asks whether a file or directory is being consideredby the for loop 483. If a file is being considered, data is copied toBADDR locations in a previous version of the file if the particularBADDR location includes a ditto entry referencing the deleted snapshot.

If, however, decision block 484 considers a directory, for loop 487considers each file or directory referenced by the directory consideredby for loop 483. For each referenced file or directory, processconsiders whether the snapshot ID of the referenced file or directory isless than or equal to the highest snapshot ID in the governance list ofthe previous snapshot 488. If it is, the reference to the file ordirectory is copied to the previous version. This comparison of snapshotIDs determines whether the referenced file or directory was createdafter the next-most previous snapshot was created. Thus, if thereferenced file or directory was created after the previous snapshot,then COWing the referenced file or directory is unnecessary because thereferenced file or directory did not exist at the time the previoussnapshot was created. After all of the referenced files or directorieshave been considered, the for loop 487 ends 489.

After the file or directory in the snapshot tracking file has been COWed486, 488, operations 492 and 493 execute. Then, after all of the filesand directories in the snapshot tracking file have been considered, thefor loop 483 ends 490. Next, the snapshot tracking file associated withthe snapshot is deleted 494, and the delete snapshot process 480 ends495.

While FIG. 8 illustrates one embodiment of a delete snapshot operation480, it is recognized that other embodiments may be used. For example,the inputs and outputs may be passed as values, references, and/orstores in an accessible memory location.

VIII. Read File

FIG. 9 illustrates one embodiment of a flowchart of operations 700 forreading a version of a file governed by a snapshot. In the depictedembodiment, the metatree is the current version of a file includesaddresses in all of its BADDR locations. That is, no ditto records arefound in the current version. Thus, the current version can be readdirectly by accessing the metatree and referencing the indicatedlocations on the physical disk. However, when accessing a snapshotversion of a file, some BADDR locations may include a ditto record. Forthese BADDR locations, subsequent versions of the file need to beaccessed until a location is reached that includes an address (“a realBADDR record”).

In one embodiment, the read file process 700 begins 701 by receiving theLIN of the file version to be read 702 and the snapshot ID of the fileversion 703. In another embodiment, the path to the file version isreceived. In one embodiment, the snapshot ID of the file version 703 isstored in an in-memory cache structure. In embodiments that utilize theuser interface described with respect to FIG. 28, the path includes a.snapshot/subdirectory if a snapshot version is sought.

Next, the process gets the inode that corresponds to the receivedLIN/snapshot ID pair. This step can be performed using lookup techniquesknown to those with ordinary skill in the art.

After the inode has been retrieved, a for loop 705 considers each BADDRlocation in the portion of the metatree being read. Then, for each BADDRlocation, decision block 706 asks whether there is a real BADDR recordexists. If a real BADDR record exists, the process looks up the BADDR onthe physical disk 708 and retrieves data. However, if a real BADDRrecord does not exist, the process reads the next inode version 707.Again, the process will determine if a real BADDR record exists in thenext version 706. The process will continue looking to subsequentversions 707 until it finds a real BADDR record in the considered BADDRlocation. When a real BADDR record is found, the process looks up theBADDR on the physical disk 708 and retrieves the data.

After all of the BADDR locations in the portion of the metatree beingread have been considered, the for loop ends 709 and the read fileprocess ends 710.

While FIG. 9 illustrates one embodiment of a read file operation 700, itis recognized that other embodiments may be used. For example, theinputs and outputs may be passed as values, references, and/or stores inan accessible memory location.

IX. Directory Lookup

FIG. 10 illustrates one embodiment of a flowchart of operations forperforming a lookup operation 800 on a version of a directory governedby a snapshot. This process permits a user or client application todetermine whether a target file or directory is located in a particularsnapshot version of a directory. For example, if the user or clientapplication wants to access the version of a target file at the time aparticular snapshot was created, process 800 determines whether thetarget file existed at the time of the snapshot. If the target file didexist for that snapshot, the process returns the location of the file.However, if the target file did not exist for that snapshot, the processreturns an indication that the target file could not be found.

In one embodiment, the directory lookup process 800 begins 801 byreceiving a target file or directory. The target file or directory isthe version of a file or directory a user or client application wishesto access from a particular snapshot. Next, the process receives theLIN/snapshot ID of the particular snapshot 803, the “relevant snapshot,”of a parent directory, the “relevant directory,” that may or may notinclude the target file or directory.

Then, a for loop 804 considers all snapshots of the relevant directorythat have a snapshot ID greater than or equal to the snapshot ID of therelevant snapshot. In one embodiment, the range of snapshots areconsidered from oldest to newest. Considering the snapshots in this waycan speed up the lookup operation for target files or directories thathave been modified frequently. That is, if the target file or directoryhas been modified frequently, the COWed version of the target file ordirectory is more likely to appear as an entry in an older version ofthe relevant directory rather than a newer version of the relevantdirectory. In other embodiments, the for loop 804 considers the range ofsnapshots from newest to oldest. Considering snapshots in this order ismore efficient for target files directories that are rarely, if ever,modified because they are more likely to appear in a newer version ofthe relevant directory.

For the snapshot being considered, the process performs a lookup in themetatree of the relevant directory for the target file or directory. Inother embodiments, the lookup may be performed in another data structurethat stores entries corresponding to the children of the relevantdirectory.

Next, decision block 806 asks whether an entry matching the target fileor directory is found in the metatree of the considered version of therelevant directory. If it is not, the next snapshot is considered 804and the lookup is repeated 805. However, if a matching entry is found inthe considered version, decision block 807 asks whether the genesissnapshot ID of the matching entry is less than the snapshot ID of therelevant version. If the genesis snapshot ID of the entry is less thanthe snapshot ID of the relevant version 807, the for loop breaks 809 andthe location or path of the appropriate version of the target file ordirectory is returned 811. Then, the process 800 ends 810.

However, if the genesis snapshot ID of the matching entry is not lessthan the snapshot ID of the relevant version 807, the matching entry wasa version created after the relevant snapshot and was, therefore, not anentry in the relevant version of the relevant directory. The processthen considers the next snapshot within the range. If the for loop 804considers every snapshot within the range and is unable to find amatching entry 806 with a genesis snapshot ID less than the snapshot IDof the relevant version 807, the for loop 804 ends 808. Thus, theprocess returns an indication that the target file or directory was notfound 812.

While FIG. 10 illustrates one embodiment of a directory operation 800,it is recognized that other embodiments may be used. For example, theinputs and outputs may be passed as values, references, and/or stores inan accessible memory location.

X. Read Directory

FIG. 11 illustrates one embodiment of a flowchart of operations forperforming a read directory operation 900 on a version of a directorygoverned by a snapshot. In the depicted embodiment, the read directoryoperation returns one entry (such as, a file or a directory) located ina version (or, “relevant version”) of a directory (or, “relevantdirectory”) each time it is executed. It will be appreciated by one withordinary skill in the art that the depicted embodiment may be modifiedto return some or all of the entries located within the relevant versionof the relevant directory.

Because the depicted embodiment, returns only one entry from therelevant version at a time, an index is used. The index serves as abookmark that indicates which entry in the relevant version the readdirectory operation returned last. In the depicted embodiment, thebookmark is implemented using a variable named NEXT INDEX. In oneembodiment, NEXT INDEX is the key of the directory entry in the B-treestructure of the relevant directory. It will be appreciated by one withskill in the art that the key is a value that is a identifier of theentry that is unique to at least one of a file system, a B-tree, astorage node, and a storage device. Accordingly, NEXT NAME is the nameof the entry that has a key equal to NEXT INDEX.

Additionally, because the read directory operation 900 returns one entryat a time, the process returns an entry in response to an index value,PREVIOUS INDEX, that corresponds to the key of the last entry returnedby the operation. The use of PREVIOUS INDEX helps ensure that process900 does not return entries that were previously returned. Thus, process900 is a function of PREVIOUS INDEX.

The process 900 begins 901 by receiving the snapshot ID of the relevantsnapshot 902. Then, the process gets all snapshots with snapshot IDsgreater than or equal to the snapshot ID of the relevant snapshot 903.In one embodiment, the process retrieves this range of snapshots becauseentries for a particular version of a directory are stored either as anentry in that directory version or in subsequent versions. Thus, theprocess looks at the relevant version or look ahead to retrieve entrieslocated within the relevant version. After the inodes are retrieved 903,the process creates the variable NEXT NAME, and the variable NEXT INDEX,initializing it to a value of MAX_INT 904.

Then, a for loop 905 considers each of the retrieved inodes. Next, anested for loop 906 considers each entry in the version considered byfor loop 905, starting at a location in the relevant directorycorresponding to PREVIOUS INDEX+1.

Decision block 907 asks whether the index of the considered entry isgreater than NEXT INDEX. For the first entry considered, the index ofthe entry will not be greater than NEXT INDEX because NEXT INDEX isinitialized to MAX_INT. However, for subsequent considered entries, ifthe index of the entry is greater than NEXT INDEX, the for loop 906breaks 908 and the next version of the relevant directory is considered905.

If the index of the considered entry is not greater than NEXT INDEX 907,decision block 909 asks whether the genesis snapshot ID of the entry isless than or equal to the snapshot ID of the relevant version. If it isnot, the next entry in the version is considered 906.

However, if the genesis snapshot ID of the considered entry is less thanor equal to the snapshot ID of the relevant version, the entry wascreated before the relevant version and is, therefore, a child of therelevant version of the relevant directory. Thus, NEXT NAME is assigneda value that corresponds to the name of the considered entry, and NEXTINDEX is assigned a value that corresponds to the index of the entry910. Next, for loop 906 breaks 911 and the next inode version isconsidered 905. However, if all of the entries in the considered versionhave neither an entry index greater than NEXT INDEX 907 nor a genesissnapshot ID less than or equal to the snapshot ID of the relevantversion 909, for loop 906 ends 912 and the next version is considered905.

Even if the operation of block 910 executes in a previous iteration offor loop 905, the next version is considered because there could existan entry that has an index that is greater than PREVIOUS INDEX+1 butless than the present value of NEXT INDEX. After all versions of therelevant directory within the range have been considered, for loop 905ends 913. Next, decision block 914 asks whether NEXT NAME stores avalue. If it does store a value, an entry within the relevant versionwith an index greater than PREVIOUS INDEX was found, and the processreturns NEXT NAME and NEXT INDEX 916. However, if NEXT NAME does notstore a value, no entry in the relevant version with an index greaterthan PREVIOUS INDEX was found, and the process returns “NO MORE ENTRIESEXIST” 915.

While FIG. 11 illustrates one embodiment of a directory operation 900,it is recognized that other embodiments may be used. For example, allentries may be returned by recursively calling operations 905-916 andreassigning PREVIOUS INDEX to equal NEXT INDEX, each time the operations905-916 are called. Additionally, the inputs and outputs may be passedas values, references, and/or stores in an accessible memory location.

XI. File Structure Implementations

In the embodiment discussed above, inodes associated with filesreference BADDR locations in a metatree that store either real BADDRrecords or ditto records which reference the next version of the file.For ease of reference, this file structure implementation will bereferred to as the logical model. However, it is recognized that otherfile structure implementations exist, such as, for example, a physicalmodel, a hybrid model and a log-based model. Each of these models isdescribed in detail below.

a. Logical Model

FIG. 12A illustrates one embodiment of a logical model file structureimplementation. The logical model utilizes an inode/metatree pair forthe current version of the file and an inode/metatree pair for eachsnapshot version of the file. Metatree 1022 represents the currentversion of a file and metatree 1020 represents a snapshot version of thefile. The current version stores records for all BADDR locations in themetatree that point to the physical disk 1024. Thus, the BADDR addressescorresponding to locations 1001 reference data blocks 1004, BADDRlocations 1002 reference data blocks 1005, and BADDR locations 1003reference data blocks 1006.

The snapshot version of the file only references data blocks on thephysical disk 1024 that have been modified and thereby COWed since thesnapshot was created. Accordingly, because BADDR locations 1002 weremodified, BADDR locations 1010 reference data blocks 1007. The remainingBADDR locations in the snapshot version 1009, 1011 include ditto recordswhich reference the next-most recent version 1022. Accordingly, dittorecords such as 1009 and 1011 can represent large amounts of data byacting as a compact place-holder.

b. Physical Model

FIG. 12B illustrates one embodiment of a physical model file structureimplementation. The physical model utilizes an inode/metatree pair forthe current version of the file and an inode/metatree pair for eachsnapshot version of the file. The current version stores records for allBADDR locations in the metatree that point to the physical disk 1054.Thus, the BADDR addresses corresponding to locations 1036 reference datablocks 1031, BADDR locations 1037 reference data blocks 1032, and BADDRlocations 1038 reference data blocks 1033.

The snapshot version 1050 of the file references data blocks in the sameway that the current version 1052 references data blocks. BADDRlocations 1039 references the same data blocks 1031 as BADDR locations1036 because the data was not modified after the snapshot was created,and BADDR locations 1041 similarly reference the same data blocks 1033as BADDR locations 1038. However, BADDR locations 1040 referencedifferent data blocks than BADDR locations 1037 because this portion ofthe file was modified and consequently COWed. Accordingly, BADDRlocations 1040 reference data blocks 1034.

The physical model offers identical snapshot version and current versionread times because real BADDR locations are stored in all BADDRlocations of the snapshot version. That is, the indirection of thephysical model is not present. However, the physical model may be lessdesirable than the logical model because unchanged portions of themetatree cannot be compactly stored using ditto records.

c. Hybrid Model

FIG. 12C illustrates one embodiment of a hybrid model file structureimplementation. In the hybrid model, the current version and all snapshot versions are stored in a single inode/metatree pair. BADDRlocations 1065, 1066, and 1067 represent the current version.Accordingly, BADDR locations 1065, 1066 and 1067 reference data blocks1061, 1062 and 1063, respectively, and BADDR locations 1068, 1069 and1070 represent a snapshot version. Because the data in BADDR locations1065 was not modified after the snapshot was created, BADDR locations1068 reference BADDR locations 1065 of the current version. Similarly,BADDR locations 1070 references BADDR locations 1067 of the currentversion. However, because the data in BADDR locations 1066 was modifiedafter the snapshot was created, BADDR locations 1070 references datablocks 1064.

The hybrid model may be more desirable than the logical model when alarge number of snapshots have been modified frequently because theindirection in between data structured in the logical model may slowdown read operations. However, lookups for delete snapshot operations ina potentially large metatree of the hybrid model may be computationallyexpensive.

d. Log-Based Model

FIG. 12D illustrates one embodiment of a log-based model file structureimplementation. In the log-based model, the current version of a file isstored in an inode/metatree pair 1092 that references the physical disk1094. Portions of the file that have been modified are COWed to a log1090 that is referenced by the metatree associated with the currentversion 1092. Thus, BADDR locations 1088 stored COWed data because datain BADDR locations 1086 have been modified. Reading snapshot data underthe log-based model can be performed by reconstructing versions of thefile by accessing both the log and the current version of the file. Forexample, in the depicted embodiment, reading the snapshot data wouldrequire accessing BADDR locations 1085, 1088 and 1087.

The log-based model may be more desirable than the other models becausesnapshot data can be stored compactly, permitting tracking of evensingle-byte modifications. However, the log-based model may be lessdesirable than the other models because read operations are morecomputationally expensive.

XII. Exemplary Applications

FIGS. 13A-D and FIGS. 14A-D provide examples of operations in a filesystem that implements one embodiment of the snapshot disclosed herein.It is recognized that, though considered, not all possible operationsare discussed.

a. File Operations

FIG. 13A illustrates one embodiment of a file. The depictedinode/metatree pair corresponds to the current version of a file that isgoverned by a snapshot. The inode 500 comprises fields corresponding tothe mode 501, LIN 502, and the governance list 503. The inode 500 pointsto the metatree associated with the file 504. The metatree is comprisedof BADDR locations that reference blocks on the physical disk.

Before the snapshot governed the file, the governance list of the filestored an empty set, indicating that no snapshots govern the file.Reference to FIG. 6, illustrates the creation of the snapshot of thefile shown in FIG. 12A. The process received the path of the file 402 asthe root of the snapshot. Next, a snapshot tracking data structure (notshown in FIG. 12A) was created that corresponds to the snapshot taken ofthe file 403. The global count at the time the snapshot was created isadded to the snapshot tracking data structure 404. This value is thesnapshot ID. In this example, the snapshot ID is 499.

Because the file is not the root of the file system, a mini-snapshot iscreated for each of the ancestors of the file to the root of the filesystem 406, 407, 408. Next, the snapshot ID is added to the governancelist of the inode associated with the current version of the file 409.Thus, though the governance list of the snapshot was formerly an emptyset, the snapshot of the file is created once the snapshot ID, 499, isadded to the governance list 503 of the file's inode 500.

Additionally, the LIN table 505 includes an entry 506 that referencesthe current version of the file. The entry 506 indicates the LIN of thefile, 9000, and the genesis snapshot ID of the inode, MAX_INT. MAX_INTis used to indicate that the entry 506 references the most currentversion of the file. In the depicted embodiment, the LIN table 505 doesnot include an entry for snapshot ID 499, either before or aftersnapshot creation, because the current version was not modified afterthe snapshot was created. In this embodiment, if a user or clientapplication wishes to access snapshot 499, a lookup in the LIN willreveal no entry for snapshot 499 and consequently, the inode with thenext highest snapshot ID, MAX_INT, is accessed. In other embodiments,the LIN table 505 may include an entry with LIN 9000 and genesissnapshot ID 499 that references the current version of the file. Inother words, there would be two entries in the LIN table 505 thatreference the same inode.

FIG. 13B illustrates the embodiment of FIG. 12A after two operationshave been executed: a second snapshot of the file was created, and then,a portion of the file was modified.

When the second snapshot was created, process 400 of FIG. 6 was executedin a similar manner as described above with respect to snapshot 499. Forthis snapshot, the global count was 500 at the time the second snapshotwas created. Therefore, the governance list of the inode associated withthe current version listed snapshot IDs 499 and 500. Immediately aftersnapshot 500 was created, the LIN table did not change. Thus, a lookupfor snapshot ID 500 would yield no match and the next highest snapshotID, MAX_INT, would be accessed.

Next, the data associated with BADDR locations 300-600 505 in thecurrent version were modified. Reference to FIG. 7A illustrates therelevant operations for modifying the current version of the file. Theprocess begins 601 by calling the painting process 602 depicted in FIG.7B. In the painting process 602, decision block 621 asks whether thesnapshot ID of the target file/dir is less than the global count.Because we assume that the global count is 500, the snapshot ID, 500, isequal to the global count. Thus, the operations of the painting process602 are not required and process 602 ends 636.

Next, decision block 603 asks whether the file is governed by asnapshot. The governance list of the current version indicates that bothsnapshots 499 and 500 govern the current version of the file. Thus, thecreate snapshot version of file/dir process 604 is called. First, theLIN of the file, 9000 is added to the tracking file of the governingsnapshot (not shown) 611. Next, the inode of the file is copied 612. Thecopy of the inode is represented by data structure 510 in FIG. 13B.Accordingly, the inodes of the current version 500 and snapshot version510 differ in that the snapshot version is governed by snapshot IDs 499and 500 whereas, the current version is no longer governed by asnapshot. Finally, the LIN of the snapshot version is added to the LINtable 550. As depicted, LIN 9000 with snapshot ID 500 is added to theLIN table. Notably, snapshot ID 499 does not have to be added to the LINtable because snapshots 499 and 500 reference the same metatreelocations.

Then, decision block 606 asks whether a file or a directory is beingmodified. Because a file is being modified, the file COW process 605 ofFIG. 7D is called. The file COW process first asks whether a previousversion of a file exists 641. In this example, previous versionscorresponding to snapshot IDs 499 and 500 exist. Thus, decision block642 asks whether there is a ditto record for the BADDR locations to bemodified in the previous version. Because there have been no previousmodifications to the file, all BADDR locations in the previous versioninclude a ditto record. Thus, the ditto record from BADDR locations300-600 in the snapshot version are removed 644 and the original datafrom BADDR locations 300-600 in the current version are copied to BADDRlocations 300-600 in the snapshot version 645. Next, the BADDR locations300-600 in the current version can be modified 646. Thus, the snapshotversion includes ditto records for BADDR locations 0-300 514 and601-1000 516. BADDR locations 300-600 515 includes references to theportion of the physical disk that stores the COWed data.

FIG. 13C illustrates an extension of the preceding example. Theembodiment depicted shows the data structures associated with thesnapshot versions 510, 520 and the current version 500 after theexecution of two operations: a new snapshot was created, and then, thecurrent version of the file was modified.

As discussed above with respect to FIGS. 13A and 13B, the snapshotcreation process 400, adds the snapshot ID of the snapshot to thegovernance list of the current version 503. Assuming that the globalsnapshot count at the time the snapshot is taken is 501, snapshot ID 501is added to the governance list of the current version and a snapshottracking file associated with snapshot 501 (not shown) is created.

Next, a user or client application wishes to modify the data associatedwith BADDR locations 0-100 504 in the current version. Assuming that theglobal count is 501, the painting process 602 is bypassed because thesnapshot ID, 501, is equal to the global count 621. Next, the LIN isadded to the snapshot tracking file associated with snapshot 501 611,the inode of the current version is copied 612 so as to correspond tosnapshot 501 520, and the new inode is added to the LIN table 613. Asshown, the LIN table 550 includes new row 553 with the LIN/snapshot IDpair (9000, 501). This row 553 points to the inode associated withsnapshot 501 520.

Next, because a file is being modified, the file COW process 605 iscalled. Because there exists a previous version of the file 641 with aditto record in the BADDR locations to be modified 524, the data inBADDR locations 0-100 504 from the current version are copied to BADDRlocations 0-100 524 of snapshot 501. Next, the data associated withBADDR locations 0-100 504 in the current version may be modified. Thus,in snapshot 501, BADDR locations 0-100 524 include a reference to thephysical disk, and BADDR locations 101-1000 524 include ditto records.

Notably, in order to modify the current version governed by snapshot501, changes to the metatrees associated with snapshot IDs 499 and 500510 are not required. Therefore, snapshot version 500 is read in thefollowing way: for BADDR locations 0-100, the ditto record referencesversion 501 which includes references to the physical disk; for BADDRlocations 101-300, ditto records in version 500 and 501 reference thecurrent version which includes references to the physical disk; BADDRlocations 301-600 include direct references to the physical disk; andfor BADDR locations 601-1000, ditto records in version 500 and 501reference the current version which includes references to the physicaldisk. Therefore, to read the entire contents of version 500, themetatrees for version 500, version 501 and the current version need tobe accessed.

FIG. 13D illustrates an extension of the preceding example. Theembodiment depicted shows the deletion of snapshot 501. Reference toFIG. 8 illustrates the operations executed in order to delete snapshot501. After the delete snapshot request is accepted 482, for loop 483considers each file or directory in the snapshot tracking file ofsnapshot 501. In this example, the root of the snapshot is a file thathas no children. Therefore, the only entry in the snapshot tracking fileof snapshot 501 corresponds to LIN 9000. Therefore, the operations infor loop 483 will execute only once. Decision block 484 asks whetherthere is a previous version of the file. Because snapshots 499 and 500are previous versions of the file, the process proceeds to decisionblock 485 which determines that a file is under consideration. Next, thedata from the snapshot to be deleted is copied to a previous version ofthe file. In the example, snapshot 501 stored real BADDR records only inlocations 0-100. Therefore, only these records need to be copied to thesame locations in the metatree 517 for snapshot 500.

Then, the inode and metatree associated with version 501 520 can bedeleted 492, and the reference 553 in the LIN table to snapshot 501 canbe deleted 493. In other embodiments, the entire row in the LIN tablemay be deleted. Because only one file was under consideration, for loop483 ends 490 and the snapshot tracking file associated with snapshot 501is deleted.

After the deletion of snapshot 501, a read operation on version 500proceeds in the following manner. First, the inode of the file isreceived and each BADDR location in the region being read is considered.For locations 0-100 517, data can be accessed by performing a lookup ofthe BADDR locations on the physical disk 708 because a real BADDR recordexists 706 for these locations. However, for BADDR locations 101-300518, the next inode version needs to be read to find a real BADDRrecord. Thus, a lookup on the physical disk relies on real BADDR records508. Similarly, a read on BADDR locations 301-600 515 occurs in asimilar way to BADDR locations 0-100 517 because a real BADDR recordexists. A read on BADDR locations 601-1000 516 occurs in a similar wayto BADDR locations 101-300 518 because a ditto record exists.

b. Directory Operations

FIG. 14A illustrates one embodiment of a directory, dir2/, governed bysnapshot 602. When the directory was created, the inode 560 included anempty set in its governance list 563. The metatree for dir2/ includesentries 564, 565, 566 associated with its child inodes. For example,file4 with LIN 5001 was added when the global snapshot count was 597;dir3/ with LIN 5002 was added when the global snapshot count was 596;and file5 with LIN 5003 was added when the global snapshot count was601. Note the deviation from the example file hierarchy in FIG. 2A (suchas, in FIG. 14A, file5 is a child of dir2/).

Assuming the global snapshot count is 602 at the time the first snapshotof dir2/ is created, creation of a snapshot with a root of dir2/ firstcreates a snapshot tracking file 403 and adding snapshot ID 602 to thesnapshot tracking file 404. Then, a mini-snapshot for each parent ofdir2/ to the root is created 406, 407, 408 because dir2/ is not the rootof the file system 405. Next, snapshot ID 602 is added 409 to thegovernance list 563 of the current version of dir2/ 409.

FIG. 14B illustrates an extension of the preceding example. The depictedembodiment shows the inode/metatree pair 570 associated with snapshot602 and the inode/metatree 560 pair associated with the current versionafter file4 has been deleted from the current version. FIG. 7A providesone embodiment of the operations for deleting file4 from the currentversion. First, assuming the global snapshot count is 602, the paintingprocess 602 is skipped because the snapshot ID, 602, is equal to theglobal snapshot count 621. Next, a snapshot version of dir2/ is createdby the create snapshot version of file/dir process 604. Process 604 addsthe LIN of file4, 5001, to the snapshot tracking file 611 associatedwith snapshot 602; makes a copy of the inode of the current version 612;and adds the LIN/snapshot ID pair, (5000, 602) to the LIN table (notshown). Notably, when the inode is copied, the governance list of thesnapshot version 573 is 602, and the governance list of the currentversion 563 includes an empty set.

Then, the directory COW process 607 is executed because a file includedin dir2/ is being modified. When removing an entry 651, the directoryCOW process asks 654 whether the genesis snapshot ID of file4 is morerecent than the snapshot 602. Because the genesis snapshot ID of file4is 597 and the governing snapshot ID is 602, the entry for file4 iscopied 655 to the same key location 574 in the metatree for snapshot602. Next, file4 is removed from the current version 655. Generally,after a file is modified, the genesis snapshot ID of the file in thecurrent version is set to the global snapshot count 657. However, inthis example, the genesis snapshot ID for file4 is not set to the globalsnapshot count because file4 was deleted from the current version.

FIG. 14C illustrates an extension of the preceding example. Theillustrated embodiment shows the inodes/metatree pairs associated withsnapshot 602 570, snapshot 603 580 and the current version 560 after thefollowing operations have executed in the recited order: (1) a snapshotwas created when the global count was 603, (2) file5 was modified whenthe global snapshot count was 604, and (3) file6 was added when theglobal snapshot count was 604.

As discussed above with respect to FIGS. 14A and 14B, snapshot 603 iscreated by adding snapshot ID 603 to the governance list of the currentversion. Additionally, a snapshot tracking file with snapshot ID 603 iscreated. Then, when a request to modify file5 is accepted, the inode ofthe current version is copied. The copied inode 580 includes thesnapshot ID 603 in its governance list 583, and the governance list ofthe current version 563 includes an empty set. Before file5 can bemodified, it is copied to snapshot 603 because its snapshot ID isgreater than genesis snapshot ID 601 of file5. After the COW 655 iscomplete, file5 is modified in the current version 656. Accordingly, thegenesis snapshot ID of file5 in the current version 568 is set to globalcount 604, indicating when file5 was last modified.

Next, file6 with LIN 5004 is added to dir2/ when the global count was604. FIG. 7E illustrates how an entry may be added to a directorygoverned by a snapshot. First, the entry is added to the metatreeassociated with the inode of the current version 652. Then, in the LINtable, the snapshot ID for the entry is the same as the snapshot ID ofthe current version 653. Also, the genesis snapshot ID of file6 569 inthe metatree of the current version of dir2/ is set to the global count.

In order to perform a lookup operation for a particular file ordirectory in a particular version of dir2/, the directory lookup process800 first receives the target file or directory and the LIN/snapshot IDpair of the relevant directory 803. For example, assume that the targetfile or directory is file5 and that the lookup operation is directed tothe version 602 of dir2/, snapshot ID pair (5000, 602).

For loop 804 first examines snapshot 602 and determines that there is nomatching entry in the local portion of the tree 806. Next, snapshot 603is considered. A matching entry for file5 exists in the local portion ofthe tree 806. Thus, to determine if the matching entry was included inthe current version of dir2/, decision block 807 asks whether thesnapshot ID is less than the snapshot ID of the relevant version. Here,the snapshot ID for file5 in snapshot 603 is 601, and the snapshot ID ofthe relevant version is 602. Therefore, the for loop breaks 809 and thelocation and/or the path of file5 with genesis snapshot ID 601 isreturned.

In order to perform a read directory operation for a particular versionof dir2/, the read directory process 900 first receives the inodes forthe snapshot versions that have snapshot IDs greater than the snapshotID of the relevant version. For example, assume that the read directoryoperation is directed to snapshot 603 of the dir2/. Accordingly, theinodes for snapshot 603 and the current version are received. Toretrieve each entry in version 603 of dir2/, the read directoryoperation examines each entry 906 in each received inode version 905. Ifthe genesis snapshot ID of the considered entry is less than or equal tothe snapshot ID of the relevant version 909, the process returns thename of the entry 916. However, if the snapshot ID of the entry isgreater than the snapshot ID of the relevant entry, the processconsiders the next entry 911.

In the illustrated example, the process first considers file5 in version603. It is returned as an entry in this version of dir2/ because itssnapshot ID, 601, is less than the relevant snapshot ID, 603. Similarly,the snapshot ID of each entry in the current version is considered.Therefore, dir3/ is the only entry returned because the entries forfile5 and file6 each have snapshot IDs greater than the snapshot ID ofthe relevant version. Thus, a read directory operation for the entirecontents of snapshot version 603 of dir2/ would indicate that dir2/includes file5 (with genesis snapshot ID 601) and dir3/ (with genesissnapshot ID 598).

FIG. 14D illustrates an extension of the preceding example. In thedepicted embodiment, the metatrees associated with snapshot 602 570 andthe current version 560 are shown after snapshot 603 has been deleted.In order to delete snapshot 603, each file or directory in the snapshottracking file for snapshot 603 is visited 483. Here, the only file inthe snapshot tracking file for snapshot 603 is file5 with genesissnapshot ID 601. Thus, because a previous version, snapshot 602, ofdir2/ exists and file5 is a file, the entry in snapshot 603 is copied tosnapshot 602. Then, the inode and metatree for snapshot version 603 offile5 is deleted 492, and the entry associated with the LIN/snapshot IDpair (5003, 603) is deleted from the LIN table 493. Afterward, thesnapshot tracking file, inode and metatree associated with snapshot 603of dir2/ are deleted 494.

XIII. Other Embodiments

While certain embodiments of the invention have been described, theseembodiments have been presented by way of example only, and are notintended to limit the scope of the present invention. Accordingly, thebreadth and scope of the present invention should be defined inaccordance with the following claims and their equivalents.

By way of example, the following alternatives are also contemplated.Although the data structures described herein have been directed to adistributed system, some embodiments of the invention may be used in asingle file system. Additionally or alternatively, it will be recognizedby one with ordinary skill in the art that the depicted embodiments maybe modified to accommodate file structures under the logical model,physical model, hybrid model and/or log-based model. Further, inaddition to adding the snapshot ID to the root of the snapshot uponsnapshot creation, the snapshot ID may be added to some or all of thefiles and directories governed by the snapshot. Additionally, it isrecognized that the root of a snapshot can be a single file or directoryor more than one file or directory. Embodiments of a systems and methodsfor performing a reverse lookup are disclosed in U.S. patent application______ [ISIL.0016A], titled “SYSTEMS AND METHODS OF REVERSE LOOKUP,”filed on the same day as this application and is hereby incorporated byreference in its entirety.

The above-mentioned alternatives are examples of other embodiments, andthey do not limit the scope of the invention. It is recognized that avariety of data structures with various fields and data sets may beused. In addition, other embodiments of the flow charts may be used.

1. A data storage system for providing intuitive access to previousversions of files or directories, the system comprising: at least onecomputer processor; at least one memory; a file system stored on the atleast one memory, the file system comprising multiple data structureslogically arranged hierarchically, each data structure comprising a fileor directory, the multiple data structures comprising: a root datastructure; a target data structure; a non-ancestor subset of datastructures which are descendants of the root data structure and whichare not in a path between the root data structure and the target datastructure; and an ancestor subset of data structures providing an accesspath between the root data structure and the target data structure andproviding at least portions of access paths between the root datastructure and the non-ancestor subset of data structures; and at leastone executable software module executed by the at least one computerprocessor and configured to: generate a snapshot version of the targetdata structure; and generate a mini-snapshot version of the ancestorsubset of data structures, the mini-snapshot version of the ancestorsubset of data structures providing an access path from the root datastructure to the snapshot version of the target data structure and notproviding any portion of the access paths from the root data structureto the non-ancestor subset of data structures.
 2. The data storagesystem of claim 1, wherein the file system is a distributed file system,the at least one memory comprises a plurality of memories, and themultiple data structures are stored across the plurality of memories. 3.The data storage system of claim 1, wherein the root data structure is aroot of the file system.
 4. The data storage system of claim 1, whereinthe root data structure is not a root of the file system.
 5. The datastorage system of claim 1, wherein the at least one executable softwaremodule is further configured to store the mini-snapshot version of theancestor subset of data structures as a descendant of the root datastructure.
 6. The data storage system of claim 1, wherein the at leastone executable software module is further configured to access thesnapshot version of the target data structure using the mini-snapshotversion of the ancestor subset of data structures.
 7. The data storagesystem of claim 1, wherein the at least one executable software moduleis configured to generate the mini-snapshot version of the ancestorsubset of data structures as a result of a request to access thesnapshot version of the target data structure.
 8. The data storagesystem of claim 7, wherein the mini-snapshot version of the ancestorsubset of data structures is not previously stored in the file system.9. The data storage system of claim 7, wherein the snapshot version ofthe target data structure is accessed using a virtual directory.
 10. Thedata storage system of claim 1, wherein the multiple data structurescomprise multiple root data structures and multiple target datastructures, and the at least one executable software module isconfigured to generate a mini-snapshot version of an ancestor subset ofdata structures in an access path between any one of the root datastructures and a snapshot version of any one of the multiple target datastructures.
 11. The data storage system of claim 10, wherein themultiple root data structures comprise the directories in the filesystem, including the root directory of the file system.
 12. A method ofproviding intuitive access to previous versions of files or directories,the method comprising: generating, by a computer processor, a snapshotversion of a target data structure in a file system, the file systemcomprising multiple data structures logically arranged hierarchically,each data structure comprising a file or directory, the multiple datastructures comprising: a root data structure; the target data structure;a non-ancestor subset of data structures which are descendants of theroot data structure and which are not in a path between the root datastructure and the target data structure; and an ancestor subset of datastructures providing an access path between the root data structure andthe target data structure and providing at least portions of accesspaths between the root data structure and the non-ancestor subset ofdata structures; and generating, by the computer processor, amini-snapshot version of the ancestor subset of data structures, themini-snapshot version of the ancestor subset of data structuresproviding an access path from the root data structure to the snapshotversion of the target data structure and not providing any portion ofthe access paths from the root data structure to the non-ancestor subsetof data structures.
 13. The method of claim 12, wherein the file systemis a distributed file system, the at least one memory comprises aplurality of memories, and the multiple data structures are storedacross the plurality of memories.
 14. The method of claim 12, whereinthe root data structure is a root of the file system.
 15. The method ofclaim 12, wherein the root data structure is not a root of the filesystem.
 16. The method of claim 12, further comprising storing themini-snapshot version of the ancestor subset of data structures as adescendant of the root data structure.
 17. The method of claim 12,further comprising accessing the snapshot version of the target datastructure using the mini-snapshot version of the ancestor subset of datastructures.
 18. The method of claim 12, further comprising receiving arequest to access the snapshot version of the target data structure,wherein the generating a mini-snapshot version of the ancestor subset ofdata structures is performed after the request is received.
 19. Themethod of claim 18, wherein the generating a mini-snapshot version ofthe ancestor subset of data structures is performed as a result of thereceived request.